home *** CD-ROM | disk | FTP | other *** search
/ BBS in a Box 15 / BBS in a box XV-2.iso / Files II / Prog / M / MacPerl 4.13 source.sit / Perl Source ƒ / MacPerl / Mercutio.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-02-27  |  5.0 KB  |  153 lines  |  [TEXT/MPS ]
  1. /***********************************************************************************
  2. **
  3. **       Developer's Programming Interface for Mercutio Menu Definition Function
  4. **               © 1992 Ramon M. Felciano, All Rights Reserved
  5. **                       C port -- December 5, 1992
  6. **
  7. ************************************************************************************/
  8.  
  9. #include "Menus.h"
  10. #include "Memory.h"
  11. #include "Events.h"
  12.  
  13. #define        customDefProcSig  'CUST'
  14. #define        areYouCustomMsg  128
  15. #define        getVersionMsg  131
  16. #define        getCopyrightMsg  132
  17. #define        mMenuKeyMsg  262
  18. #define     _Point2Long(pt)    (* (long *) &pt)            // these would have pbs with register vars
  19. #define     _Long2Point(long)    (* (Point *) &long)
  20.  
  21. void InitMercutio(void);
  22. long PowerMenuKey (long theMessage, short theModifiers, MenuHandle hMenu);
  23. Boolean IsCustomMenu (MenuHandle menu);
  24. long    GetMDEFVersion (MenuHandle menu);
  25. StringHandle    GetMDEFCopyright (MenuHandle menu);
  26.  
  27. typedef pascal void (*MDEFProc)(short msg, MenuHandle theMenu, Rect* menuRect,
  28.                 Point hitPt, short *itemID);
  29.  
  30.  
  31.  
  32. /***********************************************************************************
  33. **
  34. **   GetMDEFVersion returns the MDEF version in long form. This can be typecast
  35. **     to a normal version record if needed.
  36. **
  37. ************************************************************************************/
  38. long    GetMDEFVersion (MenuHandle menu)
  39. {
  40.     SignedByte state;
  41.     Handle    proc;
  42.     Rect    dummyRect;
  43.     short    dummyInt;
  44.     Point     pt;
  45.     
  46.     proc = (*menu)->menuProc;    /* same as **menu.menuProc */
  47.     state = HGetState(proc);
  48.     HLock(proc);
  49.     dummyRect.top = dummyRect.left = dummyRect.bottom = dummyRect.right = 0;
  50.  
  51.     SetPt(&pt,0,0);
  52.     ((MDEFProc) *proc)(getVersionMsg, menu, &dummyRect, pt, &dummyInt);
  53.     HSetState(proc, state);
  54.     
  55.     /* the result, a long, is returned in dummyRect.topLeft */
  56.     return _Point2Long(dummyRect);
  57. }
  58.  
  59. /***********************************************************************************
  60. **
  61. **   GetMDEFCopyright returns a stringHandle to the copyright message for the MDEF.
  62. **
  63. **   IMPORTANT: THE CALLER IS RESPONSIBLE FOR DISPOSING OF THIS HANDLE WHEN DONE
  64. **              WITH IT.
  65. **
  66. ************************************************************************************/
  67. StringHandle    GetMDEFCopyright (MenuHandle menu)
  68. {
  69.     SignedByte state;
  70.     Handle    proc;
  71.     Rect    dummyRect;
  72.     short    dummyInt;
  73.     Point     pt;
  74.     
  75.     proc = (*menu)->menuProc;    /* same as **menu.menuProc */
  76.     state = HGetState(proc);
  77.     HLock(proc);
  78.     dummyRect.top = dummyRect.left = dummyRect.bottom = dummyRect.right = 0;
  79.  
  80.     SetPt(&pt,0,0);
  81.     ((MDEFProc) *proc)(getCopyrightMsg, menu, &dummyRect, pt, &dummyInt);
  82.     HSetState(proc, state);
  83.     
  84.     /* the result, a stringHandle, is returned in dummyRect.topLeft */
  85.     return *(StringHandle*)(&dummyRect);
  86. }
  87.  
  88. /***********************************************************************************
  89. **
  90. **   IsCustomMenu returns true if hMenu is controlled by a custom MDEF. This relies on my}
  91. **   convention of returning the customDefProcSig constant in the rect parameter: this obtuse}
  92. **   convention should be unique enough that only my custom MDEFs behave this way.}
  93. **
  94. ************************************************************************************/
  95. Boolean IsCustomMenu (MenuHandle menu)
  96. {
  97.     SignedByte state;
  98.     Handle    proc;
  99.     Rect    dummyRect;
  100.     short    dummyInt;
  101.     Point     pt;
  102.     
  103.     proc = (*menu)->menuProc;    /* same as **menu.menuProc */
  104.     state = HGetState(proc);
  105.     HLock(proc);
  106.     dummyRect.top = dummyRect.left = dummyRect.bottom = dummyRect.right = 0;
  107.  
  108.     SetPt(&pt,0,0);
  109.     ((MDEFProc) *proc)(areYouCustomMsg, menu, &dummyRect, pt, &dummyInt);
  110.     HSetState(proc, state);
  111.     
  112.     /* the result, a long, is returned in dummyRect.topLeft */
  113.     return (_Point2Long(dummyRect) == (long) (customDefProcSig));
  114. }
  115.  
  116.  
  117. /***********************************************************************************
  118. **
  119. **   PowerMenuKey is a replacement for the standard toolbox call MenuKey for use with the}
  120. **   Mercutio. Given the keypress message and modifiers parameters from a standard event, it }
  121. **   checks to see if the keypress is a key-equivalent for a particular menuitem. If you are currently}
  122. **   using custom menus (i.e. menus using Mercutio), pass the handle to one of these menus in}
  123. **   hMenu. If you are not using custom menus, pass in NIL or another menu, and PowerMenuKey will use the}
  124. **   standard MenuKey function to interpret the keypress.}
  125. **
  126. **   As with MenuKey, PowerMenuKey returns the menu ID in high word of the result, and the menu}
  127. **   item in the low word.}
  128. **
  129. ************************************************************************************/
  130.  
  131. long PowerMenuKey (long theMessage, short theModifiers, MenuHandle hMenu)
  132. {
  133.     if ((hMenu == NULL) || (!IsCustomMenu(hMenu)))
  134.     {
  135.         return(MenuKey((char)(theMessage & charCodeMask)));
  136.     }
  137.     else
  138.     {
  139.         Handle proc = (*hMenu)->menuProc;
  140.         char state = HGetState(proc);
  141.         Rect dummyRect;
  142.         Point pt = _Long2Point(theMessage);
  143.         
  144.         HLock(proc);
  145.         dummyRect.top = dummyRect.left = 0;
  146.         ((MDEFProc) *proc)(mMenuKeyMsg, hMenu, &dummyRect, pt, &theModifiers);
  147.         HSetState(proc, state);
  148.         return( _Point2Long(dummyRect));
  149.     }
  150. }
  151.  
  152.  
  153.